home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / dev / lang / python_src.lha / amigapython / objects / abstract.c next >
C/C++ Source or Header  |  1995-10-22  |  21KB  |  1,027 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Abstract Object Interface (many thanks to Jim Fulton) */
  26.  
  27. #include "Python.h"
  28.  
  29. #define Py_TRY(E) if(!(E)) return NULL
  30. #define Py_ASSERT(EXP,E,V) if(!(EXP)) return PyErr_SetString(E,V), (void*)NULL
  31. #define SPAM printf("line %d\n",__LINE__)
  32.  
  33. static PyObject *
  34. Py_ReturnMethodError(name)
  35.   char *name;
  36. {
  37.   if(! name) name = "Unknown Error";
  38.   PyErr_SetString(PyExc_AttributeError,name);
  39.   return 0;
  40. }
  41.  
  42. PyObject *
  43. Py_ReturnNullError()
  44. {
  45.   if(! PyErr_Occurred())
  46.     PyErr_SetString(PyExc_SystemError,
  47.             "null argument to internal routine");
  48.   return 0;
  49. }
  50.  
  51. int 
  52. PyObject_Cmp(o1, o2, result)
  53.   PyObject *o1;
  54.   PyObject *o2;
  55.   int *result;
  56. {
  57.   int r;
  58.  
  59.   if(! o1 || ! o2) return Py_ReturnNullError(),-1;
  60.   r=PyObject_Compare(o1,o2);
  61.   if(PyErr_Occurred()) return -1;
  62.   *result=r;
  63.   return 0;
  64. }
  65.  
  66. #if 0 /* Already in object.c */
  67. int
  68. PyCallable_Check(x)
  69.   PyObject *x;
  70. {
  71.     if (x == NULL)
  72.         return 0;
  73.     if (x->ob_type->tp_call != NULL ||
  74.         PyFunction_Check(x) ||
  75.         PyMethod_Check(x) ||
  76.         PyCFunction_Check(x) ||
  77.         PyClass_Check(x))
  78.         return 1;
  79.     if (PyInstance_Check(x)) {
  80.         PyObject *call = PyObject_GetAttrString(x, "__call__");
  81.         if (call == NULL) {
  82.             PyErr_Clear();
  83.             return 0;
  84.         }
  85.         /* Could test recursively but don't, for fear of endless
  86.            recursion if some joker sets self.__call__ = self */
  87.         Py_DECREF(call);
  88.         return 1;
  89.     }
  90.     return 0;
  91. }
  92. #endif
  93.  
  94. PyObject *
  95. PyObject_Type(o)
  96.     PyObject *o;
  97. {
  98.     PyObject *v;
  99.  
  100.     if(! o) return Py_ReturnNullError();
  101.     v = (PyObject *)o->ob_type;
  102.     Py_INCREF(v);
  103.     return v;
  104. }
  105.  
  106. int
  107. PyObject_Length(o)
  108.   PyObject *o;
  109. {
  110.   PySequenceMethods *m;
  111.  
  112.   if(! o) return Py_ReturnNullError(),-1;
  113.  
  114.   if((m=o->ob_type->tp_as_sequence) && m->sq_length)
  115.     return m->sq_length(o);
  116.  
  117.   return PyMapping_Length(o);
  118. }
  119.  
  120. PyObject *
  121. PyObject_GetItem(o, key)
  122.   PyObject *o;
  123.   PyObject *key;
  124. {
  125.   PyMappingMethods *m;
  126.  
  127.   if(! o || ! key) return Py_ReturnNullError();
  128.  
  129.   if((m=o->ob_type->tp_as_mapping) && m->mp_subscript)
  130.     return m->mp_subscript(o,key);
  131.   
  132.   if(PyInt_Check(key))
  133.     return PySequence_GetItem(o,PyInt_AsLong(key));
  134.  
  135.   PyErr_SetString(PyExc_TypeError,"expected integer index");
  136.   return NULL;
  137. }
  138.  
  139. int
  140. PyObject_SetItem(o, key, value)
  141.   PyObject *o;
  142.   PyObject *key;
  143.   PyObject *value;
  144. {
  145.   PyMappingMethods *m;
  146.  
  147.   if(! o || ! key || ! value) return Py_ReturnNullError(),-1;
  148.   if((m=o->ob_type->tp_as_mapping) && m->mp_ass_subscript)
  149.     return m->mp_ass_subscript(o,key,value);
  150.   
  151.   if(PyInt_Check(key))
  152.     return PySequence_SetItem(o,PyInt_AsLong(key),value);
  153.  
  154.   PyErr_SetString(PyExc_TypeError,"expeced integer index");
  155.   return -1;
  156. }
  157.  
  158. int 
  159. PyNumber_Check(o)
  160.   PyObject *o;
  161. {
  162.   return o && o->ob_type->tp_as_number;
  163. }
  164.  
  165.  
  166. #define BINOP(opname, ropname, thisfunc) \
  167.     if (!PyInstance_Check(v) && !PyInstance_Check(w)) \
  168.         ; \
  169.     else \
  170.         return PyInstance_DoBinOp(v, w, opname, ropname, thisfunc)
  171.  
  172. PyObject *
  173. PyNumber_Or(v, w)
  174.     PyObject *v, *w;
  175. {
  176.         extern int PyNumber_Coerce();
  177.  
  178.     BINOP("__or__", "__ror__", PyNumber_Or);
  179.     if (v->ob_type->tp_as_number != NULL) {
  180.         PyObject *x;
  181.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  182.         if (PyNumber_Coerce(&v, &w) != 0)
  183.             return NULL;
  184.         if ((f = v->ob_type->tp_as_number->nb_or) != NULL)
  185.             x = (*f)(v, w);
  186.         Py_DECREF(v);
  187.         Py_DECREF(w);
  188.         if (f != NULL)
  189.             return x;
  190.     }
  191.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for |");
  192.     return NULL;
  193. }
  194.  
  195. PyObject *
  196. PyNumber_Xor(v, w)
  197.     PyObject *v, *w;
  198. {
  199.         extern int PyNumber_Coerce();
  200.  
  201.     BINOP("__xor__", "__rxor__", PyNumber_Xor);
  202.     if (v->ob_type->tp_as_number != NULL) {
  203.         PyObject *x;
  204.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  205.         if (PyNumber_Coerce(&v, &w) != 0)
  206.             return NULL;
  207.         if ((f = v->ob_type->tp_as_number->nb_xor) != NULL)
  208.             x = (*f)(v, w);
  209.         Py_DECREF(v);
  210.         Py_DECREF(w);
  211.         if (f != NULL)
  212.             return x;
  213.     }
  214.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for ^");
  215.     return NULL;
  216. }
  217.  
  218. PyObject *
  219. PyNumber_And(v, w)
  220.     PyObject *v, *w;
  221. {
  222.     BINOP("__and__", "__rand__", PyNumber_And);
  223.     if (v->ob_type->tp_as_number != NULL) {
  224.         PyObject *x;
  225.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  226.         if (PyNumber_Coerce(&v, &w) != 0)
  227.             return NULL;
  228.         if ((f = v->ob_type->tp_as_number->nb_and) != NULL)
  229.             x = (*f)(v, w);
  230.         Py_DECREF(v);
  231.         Py_DECREF(w);
  232.         if (f != NULL)
  233.             return x;
  234.     }
  235.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for &");
  236.     return NULL;
  237. }
  238.  
  239. PyObject *
  240. PyNumber_Lshift(v, w)
  241.     PyObject *v, *w;
  242. {
  243.     BINOP("__lshift__", "__rlshift__", PyNumber_Lshift);
  244.     if (v->ob_type->tp_as_number != NULL) {
  245.         PyObject *x;
  246.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  247.         if (PyNumber_Coerce(&v, &w) != 0)
  248.             return NULL;
  249.         if ((f = v->ob_type->tp_as_number->nb_lshift) != NULL)
  250.             x = (*f)(v, w);
  251.         Py_DECREF(v);
  252.         Py_DECREF(w);
  253.         if (f != NULL)
  254.             return x;
  255.     }
  256.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for <<");
  257.     return NULL;
  258. }
  259.  
  260. PyObject *
  261. PyNumber_Rshift(v, w)
  262.     PyObject *v, *w;
  263. {
  264.     BINOP("__rshift__", "__rrshift__", PyNumber_Rshift);
  265.     if (v->ob_type->tp_as_number != NULL) {
  266.         PyObject *x;
  267.         PyObject * (*f) Py_FPROTO((PyObject *, PyObject *));
  268.         if (PyNumber_Coerce(&v, &w) != 0)
  269.             return NULL;
  270.         if ((f = v->ob_type->tp_as_number->nb_rshift) != NULL)
  271.             x = (*f)(v, w);
  272.         Py_DECREF(v);
  273.         Py_DECREF(w);
  274.         if (f != NULL)
  275.             return x;
  276.     }
  277.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for >>");
  278.     return NULL;
  279. }
  280.  
  281. PyObject *
  282. PyNumber_Add(v, w)
  283.     PyObject *v, *w;
  284. {
  285.     BINOP("__add__", "__radd__", PyNumber_Add);
  286.     if (v->ob_type->tp_as_sequence != NULL)
  287.         return (*v->ob_type->tp_as_sequence->sq_concat)(v, w);
  288.     else if (v->ob_type->tp_as_number != NULL) {
  289.         PyObject *x;
  290.         if (PyNumber_Coerce(&v, &w) != 0)
  291.             return NULL;
  292.         x = (*v->ob_type->tp_as_number->nb_add)(v, w);
  293.         Py_DECREF(v);
  294.         Py_DECREF(w);
  295.         return x;
  296.     }
  297.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for +");
  298.     return NULL;
  299. }
  300.  
  301. PyObject *
  302. PyNumber_Subtract(v, w)
  303.     PyObject *v, *w;
  304. {
  305.     BINOP("__sub__", "__rsub__", PyNumber_Subtract);
  306.     if (v->ob_type->tp_as_number != NULL) {
  307.         PyObject *x;
  308.         if (PyNumber_Coerce(&v, &w) != 0)
  309.             return NULL;
  310.         x = (*v->ob_type->tp_as_number->nb_subtract)(v, w);
  311.         Py_DECREF(v);
  312.         Py_DECREF(w);
  313.         return x;
  314.     }
  315.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for -");
  316.     return NULL;
  317. }
  318.  
  319. PyObject *
  320. PyNumber_Multiply(v, w)
  321.     PyObject *v, *w;
  322. {
  323.     PyTypeObject *tp;
  324.     tp = v->ob_type;
  325.     BINOP("__mul__", "__rmul__", PyNumber_Multiply);
  326.     if (tp->tp_as_number != NULL &&
  327.         w->ob_type->tp_as_sequence != NULL &&
  328.         !PyInstance_Check(v)) {
  329.         /* number*sequence -- swap v and w */
  330.         PyObject *tmp = v;
  331.         v = w;
  332.         w = tmp;
  333.         tp = v->ob_type;
  334.     }
  335.     if (tp->tp_as_number != NULL) {
  336.         PyObject *x;
  337.         if (PyInstance_Check(v)) {
  338.             /* Instances of user-defined classes get their
  339.                other argument uncoerced, so they may
  340.                implement sequence*number as well as
  341.                number*number. */
  342.             Py_INCREF(v);
  343.             Py_INCREF(w);
  344.         }
  345.         else if (PyNumber_Coerce(&v, &w) != 0)
  346.             return NULL;
  347.         x = (*v->ob_type->tp_as_number->nb_multiply)(v, w);
  348.         Py_DECREF(v);
  349.         Py_DECREF(w);
  350.         return x;
  351.     }
  352.     if (tp->tp_as_sequence != NULL) {
  353.         if (!PyInt_Check(w)) {
  354.             PyErr_SetString(PyExc_TypeError,
  355.                 "can't multiply sequence with non-int");
  356.             return NULL;
  357.         }
  358.         return (*tp->tp_as_sequence->sq_repeat)
  359.                         (v, (int)PyInt_AsLong(w));
  360.     }
  361.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for *");
  362.     return NULL;
  363. }
  364.  
  365. PyObject *
  366. PyNumber_Divide(v, w)
  367.     PyObject *v, *w;
  368. {
  369.     BINOP("__div__", "__rdiv__", PyNumber_Divide);
  370.     if (v->ob_type->tp_as_number != NULL) {
  371.         PyObject *x;
  372.         if (PyNumber_Coerce(&v, &w) != 0)
  373.             return NULL;
  374.         x = (*v->ob_type->tp_as_number->nb_divide)(v, w);
  375.         Py_DECREF(v);
  376.         Py_DECREF(w);
  377.         return x;
  378.     }
  379.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for /");
  380.     return NULL;
  381. }
  382.  
  383. PyObject *
  384. PyNumber_Remainder(v, w)
  385.     PyObject *v, *w;
  386. {
  387.     if (PyString_Check(v)) {
  388.         return PyString_Format(v, w);
  389.     }
  390.     BINOP("__mod__", "__rmod__", PyNumber_Remainder);
  391.     if (v->ob_type->tp_as_number != NULL) {
  392.         PyObject *x;
  393.         if (PyNumber_Coerce(&v, &w) != 0)
  394.             return NULL;
  395.         x = (*v->ob_type->tp_as_number->nb_remainder)(v, w);
  396.         Py_DECREF(v);
  397.         Py_DECREF(w);
  398.         return x;
  399.     }
  400.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for %");
  401.     return NULL;
  402. }
  403.  
  404. PyObject *
  405. PyNumber_Divmod(v, w)
  406.     PyObject *v, *w;
  407. {
  408.     PyObject *res;
  409.  
  410.     if (PyInstance_Check(v) || PyInstance_Check(w))
  411.         return PyInstance_DoBinOp(v, w, "__divmod__", "__rdivmod__",
  412.                      PyNumber_Divmod);
  413.     if (v->ob_type->tp_as_number == NULL ||
  414.                 w->ob_type->tp_as_number == NULL) {
  415.         PyErr_SetString(PyExc_TypeError,
  416.             "divmod() requires numeric or class instance arguments");
  417.         return NULL;
  418.     }
  419.     if (PyNumber_Coerce(&v, &w) != 0)
  420.         return NULL;
  421.     res = (*v->ob_type->tp_as_number->nb_divmod)(v, w);
  422.     Py_DECREF(v);
  423.     Py_DECREF(w);
  424.     return res;
  425. }
  426.  
  427.  
  428. static PyObject *
  429. do_pow(v, w)
  430.     PyObject *v, *w;
  431. {
  432.     PyObject *res;
  433.     if (PyInstance_Check(v) || PyInstance_Check(w))
  434.         return PyInstance_DoBinOp(v, w, "__pow__", "__rpow__", do_pow);
  435.     if (v->ob_type->tp_as_number == NULL ||
  436.         w->ob_type->tp_as_number == NULL) {
  437.         PyErr_SetString(PyExc_TypeError,
  438.                 "pow() requires numeric arguments");
  439.         return NULL;
  440.     }
  441.     if (PyFloat_Check(w) && PyFloat_AsDouble(v) < 0.0) {
  442.         if (!PyErr_Occurred())
  443.             PyErr_SetString(PyExc_ValueError,
  444.                     "negative number to float power");
  445.         return NULL;
  446.     }
  447.     if (PyNumber_Coerce(&v, &w) != 0)
  448.         return NULL;
  449.     res = (*v->ob_type->tp_as_number->nb_power)(v, w, Py_None);
  450.     Py_DECREF(v);
  451.     Py_DECREF(w);
  452.     return res;
  453. }
  454.  
  455. PyObject *
  456. PyNumber_Power(v,w,z)
  457.     PyObject *v, *w, *z;
  458. {
  459.     PyObject *res;
  460.     PyObject *v1, *z1, *w2, *z2;
  461.  
  462.     if (z == Py_None)
  463.         return do_pow(v, w);
  464.     /* XXX The ternary version doesn't do class instance coercions */
  465.     if (PyInstance_Check(v))
  466.         return v->ob_type->tp_as_number->nb_power(v, w, z);
  467.     if (v->ob_type->tp_as_number == NULL ||
  468.         z->ob_type->tp_as_number == NULL ||
  469.         w->ob_type->tp_as_number == NULL) {
  470.         PyErr_SetString(PyExc_TypeError, "pow() requires numeric arguments");
  471.         return NULL;
  472.     }
  473.     if (PyNumber_Coerce(&v, &w) != 0)
  474.         return NULL;
  475.     res = NULL;
  476.     v1 = v;
  477.     z1 = z;
  478.     if (PyNumber_Coerce(&v1, &z1) != 0)
  479.         goto error2;
  480.     w2 = w;
  481.     z2 = z1;
  482.      if (PyNumber_Coerce(&w2, &z2) != 0)
  483.         goto error1;
  484.     res = (*v1->ob_type->tp_as_number->nb_power)(v1, w2, z2);
  485.     Py_DECREF(w2);
  486.     Py_DECREF(z2);
  487.  error1:
  488.     Py_DECREF(v1);
  489.     Py_DECREF(z1);
  490.  error2:
  491.     Py_DECREF(v);
  492.     Py_DECREF(w);
  493.     return res;
  494. }
  495.  
  496.  
  497. PyObject *
  498. PyNumber_Negative(v)
  499.     PyObject *v;
  500. {
  501.     if (v->ob_type->tp_as_number != NULL)
  502.         return (*v->ob_type->tp_as_number->nb_negative)(v);
  503.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for unary -");
  504.     return NULL;
  505. }
  506.  
  507. PyObject *
  508. PyNumber_Positive(v)
  509.     PyObject *v;
  510. {
  511.     if (v->ob_type->tp_as_number != NULL)
  512.         return (*v->ob_type->tp_as_number->nb_positive)(v);
  513.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for unary +");
  514.     return NULL;
  515. }
  516.  
  517. PyObject *
  518. PyNumber_Invert(v)
  519.     PyObject *v;
  520. {
  521.     PyObject * (*f) Py_FPROTO((PyObject *));
  522.     if (v->ob_type->tp_as_number != NULL &&
  523.         (f = v->ob_type->tp_as_number->nb_invert) != NULL)
  524.         return (*f)(v);
  525.     PyErr_SetString(PyExc_TypeError, "bad operand type(s) for unary ~");
  526.     return NULL;
  527. }
  528.  
  529. PyObject *
  530. PyNumber_Absolute(o)
  531.   PyObject *o;
  532. {
  533.   PyNumberMethods *m;
  534.  
  535.   if(! o) return Py_ReturnNullError();
  536.   if((m=o->ob_type->tp_as_number) && m->nb_absolute)
  537.     return m->nb_absolute(o);
  538.  
  539.   return Py_ReturnMethodError("__abs__");  
  540. }
  541.  
  542. PyObject *
  543. PyNumber_Int(o)
  544.   PyObject *o;
  545. {
  546.   PyNumberMethods *m;
  547.  
  548.   if(! o) return Py_ReturnNullError();
  549.   if((m=o->ob_type->tp_as_number) && m->nb_int)
  550.     return m->nb_int(o);
  551.  
  552.   return Py_ReturnMethodError("__int__");  
  553. }
  554.  
  555. PyObject *
  556. PyNumber_Long(o)
  557.   PyObject *o;
  558. {
  559.   PyNumberMethods *m;
  560.  
  561.   if(! o) return Py_ReturnNullError();
  562.   if((m=o->ob_type->tp_as_number) && m->nb_long)
  563.     return m->nb_long(o);
  564.  
  565.   return Py_ReturnMethodError("__long__");  
  566. }
  567.  
  568. PyObject *
  569. PyNumber_Float(o)
  570.   PyObject *o;
  571. {
  572.   PyNumberMethods *m;
  573.  
  574.   if(! o) return Py_ReturnNullError();
  575.   if((m=o->ob_type->tp_as_number) && m->nb_float)
  576.     return m->nb_float(o);
  577.  
  578.   return Py_ReturnMethodError("__float__");  
  579. }
  580.  
  581.  
  582. int 
  583. PySequence_Check(o)
  584.   PyObject *o;
  585. {
  586.   return o && o->ob_type->tp_as_sequence;
  587. }
  588.  
  589. int 
  590. PySequence_Length(s)
  591.   PyObject *s;
  592. {
  593.   PySequenceMethods *m;
  594.  
  595.   if(! s) return Py_ReturnNullError(),-1;
  596.  
  597.   if((m=s->ob_type->tp_as_sequence) && m->sq_length)
  598.     return m->sq_length(s);
  599.  
  600.   Py_ReturnMethodError("__len__");
  601.   return -1;
  602. }
  603.  
  604. PyObject *
  605. PySequence_Concat(s, o)
  606.   PyObject *s;
  607.   PyObject *o;
  608. {
  609.   PySequenceMethods *m;
  610.  
  611.   if(! s || ! o) return Py_ReturnNullError();
  612.       
  613.   if((m=s->ob_type->tp_as_sequence) && m->sq_concat)
  614.     return m->sq_concat(s,o);
  615.  
  616.   return Py_ReturnMethodError("__concat__");
  617. }
  618.  
  619. PyObject *
  620. PySequence_Repeat(o, count)
  621.   PyObject *o;
  622.   int count;
  623. {
  624.   PySequenceMethods *m;
  625.  
  626.   if(! o) return Py_ReturnNullError();
  627.       
  628.   if((m=o->ob_type->tp_as_sequence) && m->sq_repeat)
  629.     return m->sq_repeat(o,count);
  630.  
  631.   return Py_ReturnMethodError("__repeat__");
  632. }
  633.  
  634. PyObject *
  635. PySequence_GetItem(s, i)
  636.   PyObject *s;
  637.   int i;
  638. {
  639.   PySequenceMethods *m;
  640.   int l;
  641.  
  642.   if(! s) return Py_ReturnNullError();
  643.  
  644.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_item))
  645.     return Py_ReturnMethodError("__getitem__");  
  646.  
  647.   if(0 > (l=m->sq_length(s))) return NULL;
  648.  
  649.   if(i < 0) i += l;
  650.       
  651.   return m->sq_item(s,i);
  652. }
  653.  
  654. PyObject *
  655. PySequence_GetSlice(s, i1, i2)
  656.   PyObject *s;
  657.   int i1;
  658.   int i2;
  659. {
  660.   PySequenceMethods *m;
  661.   int l;
  662.  
  663.   if(! s) return Py_ReturnNullError();
  664.  
  665.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_slice))
  666.     return Py_ReturnMethodError("__getslice__");  
  667.  
  668.   if(0 > (l=m->sq_length(s))) return NULL;
  669.  
  670.   if(i1 < 0) i1 += l;
  671.   if(i2 < 0) i2 += l;
  672.       
  673.   return m->sq_slice(s,i1,i2);
  674. }
  675.  
  676. int
  677. PySequence_SetItem(s, i, o)
  678.   PyObject *s;
  679.   int i;
  680.   PyObject *o;
  681. {
  682.   PySequenceMethods *m;
  683.   int l;
  684.   if(! s) return Py_ReturnNullError(),-1;
  685.  
  686.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_ass_item))
  687.     return Py_ReturnMethodError("__setitem__"),-1;  
  688.  
  689.   if(i < 0)
  690.     {
  691.       if(0 > (l=m->sq_length(s))) return -1;
  692.       i += l;
  693.     }
  694.       
  695.   return m->sq_ass_item(s,i,o);
  696. }
  697.  
  698. int 
  699. PySequence_SetSlice(s, i1, i2, o)
  700.   PyObject *s;
  701.   int i1;
  702.   int i2;
  703.   PyObject *o;
  704. {
  705.   PySequenceMethods *m;
  706.   int l;
  707.  
  708.   if(! s) return Py_ReturnNullError(),-1;
  709.  
  710.   if(! ((m=s->ob_type->tp_as_sequence) && m->sq_length && m->sq_ass_slice))
  711.     return Py_ReturnMethodError("__setslice__"),-1;  
  712.  
  713.   if(0 > (l=m->sq_length(s))) return -1;
  714.  
  715.   if(i1 < 0) i1 += l;
  716.   if(i2 < 0) i2 += l;
  717.       
  718.   return m->sq_ass_slice(s,i1,i2,o);
  719. }
  720.  
  721. PyObject *
  722. PySequence_Tuple(s)
  723.   PyObject *s;
  724. {
  725.   int l, i;
  726.   PyObject *t, *item;
  727.  
  728.   if(! s) return Py_ReturnNullError();
  729.  
  730.   Py_TRY((l=PySequence_Length(s)) != -1);
  731.   Py_TRY(t=PyTuple_New(l));
  732.  
  733.   for(i=0; i < l; i++)
  734.     {
  735.       if(item=PySequence_GetItem(s,i))
  736.     {
  737.       if(PyTuple_SetItem(t,i,item) == -1)
  738.         {
  739.           Py_DECREF(item);
  740.           Py_DECREF(t);
  741.           return NULL;
  742.         }
  743.     }
  744.       else
  745.     {
  746.       Py_DECREF(t);
  747.       return NULL;
  748.     }
  749.     }
  750.   return t;
  751. }
  752.  
  753. int 
  754. PySequence_Count(s, o)
  755.   PyObject *s;
  756.   PyObject *o;
  757. {
  758.   int l, i, n=0, not_equal, err;
  759.   PyObject *item;
  760.  
  761.   if(! s || ! o) return Py_ReturnNullError(), -1;
  762.   Py_TRY((l=PySequence_Length(s)) != -1),-1;
  763.  
  764.   for(i=0; i < l; i++)
  765.     {
  766.       Py_TRY(item=PySequence_GetItem(s,i)),-1;
  767.       err=PyObject_Cmp(item,o,¬_equal) == -1;
  768.       Py_DECREF(item);
  769.       if(err) return -1;
  770.       n += ! not_equal;
  771.     }
  772.   return n;
  773. }
  774.  
  775. int 
  776. PySequence_In(s, o)
  777.   PyObject *s;
  778.   PyObject *o;
  779. {
  780.   int l, i, not_equal, err;
  781.   PyObject *item;
  782.  
  783.   if(! o || ! s) return Py_ReturnNullError(), -1;
  784.   Py_TRY((l=PySequence_Length(s)) != -1),-1;
  785.  
  786.   for(i=0; i < l; i++)
  787.     {
  788.       Py_TRY(item=PySequence_GetItem(s,i)),-1;
  789.       err=PyObject_Cmp(item,o,¬_equal) == -1;
  790.       Py_DECREF(item);
  791.       if(err) return -1;
  792.       if(! not_equal) return 1;
  793.     }
  794.   return 0;
  795. }
  796.  
  797. int 
  798. PySequence_Index(s, o)
  799.   PyObject *s;
  800.   PyObject *o;
  801. {
  802.   int l, i, n=0, not_equal, err;
  803.   PyObject *item;
  804.  
  805.   if(! s || ! o) return Py_ReturnNullError(), -1;
  806.   Py_TRY((l=PySequence_Length(s)) != -1),-1;
  807.  
  808.   for(i=0; i < l; i++)
  809.     {
  810.       Py_TRY(item=PySequence_GetItem(s,i)),-1;
  811.       err=PyObject_Cmp(item,o,¬_equal) == -1;
  812.       Py_DECREF(item);
  813.       if(err) return -1;
  814.       if(! not_equal) return n;
  815.     }
  816.   return -1;
  817. }
  818.  
  819. int 
  820. PyMapping_Check(o)
  821.   PyObject *o;
  822. {
  823.   return o && o->ob_type->tp_as_mapping;
  824. }
  825.  
  826. int 
  827. PyMapping_Length(s)
  828.   PyObject *s;
  829. {
  830.   PyMappingMethods *m;
  831.  
  832.   if(! s) return Py_ReturnNullError(),-1;
  833.  
  834.   if((m=s->ob_type->tp_as_mapping) && m->mp_length)
  835.     return m->mp_length(s);
  836.  
  837.   Py_ReturnMethodError("__len__");
  838.   return -1;
  839. }
  840.  
  841. int 
  842. PyMapping_HasKeyString(o, key)
  843.   PyObject *o;
  844.   char *key;
  845. {
  846.   PyObject *v;
  847.  
  848.   v=PyMapping_GetItemString(o,key);
  849.   if(v) return 1;
  850.   PyErr_Clear();
  851.   return 0;
  852. }
  853.  
  854. int 
  855. PyMapping_HasKey(o, key)
  856.   PyObject *o;
  857.   PyObject *key;
  858. {
  859.   PyObject *v;
  860.  
  861.   v=PyObject_GetItem(o,key);
  862.   if(v) return 1;
  863.   PyErr_Clear();
  864.   return 0;
  865. }
  866.  
  867. PyObject *
  868. PyObject_CallObject(o, a)
  869.   PyObject *o, *a;
  870. {
  871.   PyObject *r;
  872.  
  873.   if(a) return PyEval_CallObject(o,a);
  874.  
  875.   if(! (a=PyTuple_New(0)))
  876.     return NULL;
  877.   r=PyEval_CallObject(o,a);
  878.   Py_DECREF(a);
  879.   return r;
  880. } 
  881.  
  882. PyObject *
  883. #ifdef HAVE_STDARG_PROTOTYPES
  884. /* VARARGS 2 */
  885. PyObject_CallFunction(PyObject *callable, char *format, ...)
  886. #else
  887. /* VARARGS */
  888. PyObject_CallFunction(va_alist) va_dcl
  889. #endif
  890. {
  891.   va_list va;
  892.   PyObject *args, *retval;
  893. #ifdef HAVE_STDARG_PROTOTYPES
  894.   va_start(va, format);
  895. #else
  896.   PyObject *callable;
  897.   char *format;
  898.   va_start(va);
  899.   callable = va_arg(va, PyObject *);
  900.   format   = va_arg(va, char *);
  901. #endif
  902.  
  903.   if( ! callable)
  904.     {
  905.       va_end(va);
  906.       return Py_ReturnNullError();
  907.     }
  908.  
  909.   if(format)
  910.     args = Py_VaBuildValue(format, va);
  911.   else
  912.     args = PyTuple_New(0);
  913.   
  914.   va_end(va);
  915.   if(! args) return NULL;
  916.  
  917.   if(! PyTuple_Check(args))
  918.     {
  919.       PyObject *a;
  920.       
  921.       Py_TRY(a=PyTuple_New(1));
  922.       Py_TRY(PyTuple_SetItem(a,0,args) != -1);
  923.       args=a;
  924.     }
  925.   retval = PyObject_CallObject(callable,args);
  926.   Py_DECREF(args);
  927.   return retval;
  928. }
  929.  
  930. PyObject *
  931. #ifdef HAVE_STDARG_PROTOTYPES
  932. /* VARARGS 2 */
  933. PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
  934. #else
  935. /* VARARGS */
  936. PyObject_CallMethod(va_alist) va_dcl
  937. #endif
  938. {
  939.   va_list va;
  940.   PyObject *args, *method=0, *retval;
  941. #ifdef HAVE_STDARG_PROTOTYPES
  942.   va_start(va, format);
  943. #else
  944.   PyObject *o;
  945.   char *name;
  946.   char *format;
  947.   va_start(va);
  948.   o      = va_arg(va, PyObject *);
  949.   name   = va_arg(va, char *);
  950.   format = va_arg(va, char *);
  951. #endif
  952.  
  953.   if( ! o || ! name)
  954.     {
  955.       va_end(va);
  956.       return Py_ReturnNullError();
  957.     }
  958.  
  959.   method=PyObject_GetAttrString(o,name);
  960.   if(! method)
  961.     {
  962.       va_end(va);
  963.       PyErr_SetString(PyExc_AttributeError,name);
  964.       return 0;
  965.     }
  966.    
  967.   if(! (PyCallable_Check(method)))
  968.     {
  969.       va_end(va);
  970.       PyErr_SetString(PyExc_TypeError,"call of non-callable attribute");
  971.       return 0;
  972.     }
  973.  
  974.   if(format)
  975.     args = Py_VaBuildValue(format, va);
  976.   else
  977.     args = PyTuple_New(0);
  978.   
  979.   va_end(va);
  980.  
  981.   if(! args) return NULL;
  982.  
  983.   if(! PyTuple_Check(args))
  984.     {
  985.       PyObject *a;
  986.       
  987.       Py_TRY(a=PyTuple_New(1));
  988.       Py_TRY(PyTuple_SetItem(a,0,args) != -1);
  989.       args=a;
  990.     }
  991.  
  992.   retval = PyObject_CallObject(method,args);
  993.   Py_DECREF(args);
  994.   Py_DECREF(method);
  995.   return retval;
  996. }
  997.  
  998. PyObject *
  999. PyMapping_GetItemString(o, key)
  1000.   PyObject *o;
  1001.   char *key;
  1002. {
  1003.   PyObject *okey, *r;
  1004.  
  1005.   if( ! key) return Py_ReturnNullError();
  1006.   Py_TRY(okey=PyString_FromString(key));
  1007.   r = PyObject_GetItem(o,okey);
  1008.   Py_DECREF(okey);
  1009.   return r;
  1010. }
  1011.  
  1012. int
  1013. PyMapping_SetItemString(o, key, value)
  1014.  PyObject *o;
  1015.  char *key;
  1016.  PyObject *value;
  1017. {
  1018.   PyObject *okey;
  1019.   int r;
  1020.  
  1021.   if( ! key) return Py_ReturnNullError(),-1;
  1022.   if (!(okey=PyString_FromString(key))) return -1;
  1023.   r = PyObject_SetItem(o,okey,value);
  1024.   Py_DECREF(okey);
  1025.   return r;
  1026. }
  1027.